// 配置基础 API 地址
const BASE_URL = "https://jingqu.kuxia.top"; // 接口域名
const userId = "158"; // 用户 ID（字符串类型，与接口要求一致）

Page({
  /**
   * 页面的初始数据
   */
  data: {
    // 表单数据
    form: {
      title: "",
      content: "",
      type: null, // 1=攻略，2=游记，3=问答（单选互斥）
      scenicId: "", // 景区 ID（字符串类型）
      cover: "", // 封面图 URL
      mainImages: [], // 轮播图 URL 数组
    },
    // 错误提示信息
    errors: {
      title: "",
      content: "",
      type: "",
      scenicId: "",
      cover: "",
      mainImages: "",
    },
    isSubmitting: false, // 提交状态锁
    scenicData: [], // 景区列表数据
    // 线上图片资源
    imageResources: {
      back: "https://jht.jingang.icu/img/返回.png",
      home: "https://jht.jingang.icu/img/homes (1).png",
      upload: "https://jht.jingang.icu/img/upload.png",
      delete: "https://jht.jingang.icu/img/delete.png",
    },
    // Vant Uploader 组件使用的数据
    mainImageList: [],
    coverImageList: [],
  },

  /**
   * 页面加载时验证用户登录状态
   */
  verifyOpenID() {
    // 检查用户是否已登录，如果未登录则跳转到登录页面
    // 这里可以添加实际的登录验证逻辑
    console.log("验证用户登录状态");
    return true; // 示例中直接返回true
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad() {
    // 验证用户登录状态
    if (!this.verifyOpenID()) {
      wx.navigateTo({
        url: "/pages/login/login",
      });
      return;
    }

    // 隐藏小程序自带导航栏（修复API调用错误）
    wx.setNavigationBarTitle({ title: "发布攻略" });
    // wx.setNavigationBarHidden已废弃，使用自定义导航栏替代

    this.fetchScenicData();
  },

  /**
   * 获取景区列表数据 - 优化部分
   * 使用正确的接口路径app/Scenic/index和POST请求方式
   */
  fetchScenicData() {
    wx.showLoading({ title: "加载景区数据..." });
    wx.request({
      url: `${BASE_URL}/app/Scenic/index`, // 修正为正确的景区列表接口路径
      method: "POST", // 改为POST请求方式
      header: {
        "content-type": "application/json", // 添加JSON内容类型
        id: userId, // 按要求在请求头中添加id参数
        userId: userId, // 保留原有的userId参数，确保兼容性
      },
      // 如果接口需要请求体参数，可以在这里添加
      data: {
        // 可以根据实际接口需求添加参数
        // page: 1,
        // limit: 20
      },
      success: (res) => {
        wx.hideLoading();
        if (res.data && res.data.code === 1 && res.data.data) {
          // 假设接口返回的数据结构是{data: {list: [...]}}
          // 如果实际结构不同，可以根据实际情况调整
          let scenicList = res.data.data.list || res.data.data;
          // 限制景区数量为4个
          if (scenicList && scenicList.length > 0) {
            scenicList = scenicList.slice(0, 4);
          }
          this.setData({ scenicData: scenicList });
        } else {
          wx.showToast({
            title: res.data?.msg || "景区数据加载失败",
            icon: "none",
            duration: 1500,
          });
        }
      },
      fail: (error) => {
        wx.hideLoading();
        console.error("获取景区数据失败：", error);
        wx.showToast({
          title: "网络错误，请稍后重试",
          icon: "none",
          duration: 1500,
        });
      },
    });
  },

  /**
   * 标题输入事件
   */
  handleTitleInput(e) {
    this.setData({
      "form.title": e.detail.value.trim(),
      "errors.title": "",
    });
  },

  /**
   * 内容输入事件
   */
  handleContentInput(e) {
    this.setData({
      "form.content": e.detail.value.trim(),
      "errors.content": "",
    });
  },

  /**
   * 类型选择事件（确保单选互斥）
   */
   handleTypeChange(e) {
    const type = parseInt(e.detail.value);
    // 当类型改变时，清除之前可能存在的错误信息
    this.setData({ 
      'form.type': type,
      'errors.type': '',
      // 当类型改变时，只重置景区字段和相关错误信息，保留已上传的图片
      'form.scenicId': '',
      'errors.scenicId': ''
    });
  },

  /**
   * 景区选择事件
   */
  handleScenicChange(e) {
    this.setData({
      "form.scenicId": e.detail.value,
      "errors.scenicId": "",
    });
  },

  /**
   * 读取主图后的处理
   */
  afterReadMainImage(event) {
    const { file } = event.detail;
    if (Array.isArray(file)) {
      // 多选图片的情况
      this.uploadImages(file.map(item => item.url), "main");
    } else {
      // 单选图片的情况
      this.uploadImages([file.url], "main");
    }
  },

  /**
   * 读取封面图后的处理
   */
  afterReadCoverImage(event) {
    const { file } = event.detail;
    this.uploadImages([file.url], "cover");
  },

  /**
   * 删除主图
   */
  deleteMainImage(e) {
    const { index } = e.detail;
    const { mainImages, mainImageList } = this.data;
    const newMainImages = mainImages.filter((_, i) => i !== index);
    const newMainImageList = mainImageList.filter((_, i) => i !== index);
    this.setData({
      "form.mainImages": newMainImages,
      mainImageList: newMainImageList
    });
  },

  /**
   * 删除封面图
   */
  deleteCoverImage() {
    this.setData({ 
      "form.cover": "",
      coverImageList: []
    });
  },

  /**
   * 图片上传
   * @param {Array} tempPaths - 临时图片路径
   * @param {String} type - 图片类型（main/cover）
   */
  uploadImages(tempPaths, type) {
    wx.showLoading({ title: '图片上传中...' });
    const that = this;
    const { form } = this.data;
    const uploadResults = [];
    let completedCount = 0;

    tempPaths.forEach((tempPath, index) => {
      wx.uploadFile({
        url: `${BASE_URL}/app/File/file`, // 图片上传接口
        filePath: tempPath,
        name: 'file',
        header: {
          'id': userId // 头部传递用户 ID
        },
        success: (res) => {
          try {
            // 检查响应是否为有效的JSON格式
            if (res.data && res.data.trim().startsWith('{') && res.data.trim().endsWith('}')) {
              const result = JSON.parse(res.data);
              if (result.code === 1 && result.data?.url) {
                let imageUrl = result.data.url;
                // 确保图片URL是完整的绝对路径
                if (imageUrl.startsWith('/')) {
                  imageUrl = BASE_URL + imageUrl;
                }
                uploadResults[index] = imageUrl;
              } else {
                throw new Error(result.msg || '上传失败');
              }
            } else {
              // 服务器返回的不是JSON格式，可能是错误页面
              console.error('服务器返回非JSON格式响应:', res.data);
              throw new Error('服务器响应格式错误');
            }
          } catch (e) {
            console.error('图片上传解析失败：', e);
            uploadResults[index] = null;
          }
        },
        fail: (error) => {
          console.error('图片上传请求失败：', error);
          uploadResults[index] = null;
          
          // 检查是否是域名不在合法域名列表中的错误
          if (error.errMsg && error.errMsg.includes('url not in domain list')) {
            wx.showToast({
              title: '上传域名未配置，请联系管理员',
              icon: 'none',
              duration: 3000
            });
          }
        },
        complete: () => {
          completedCount++;
          // 所有上传都完成后处理结果
          if (completedCount === tempPaths.length) {
            wx.hideLoading();
            const validUrls = uploadResults.filter(url => url !== null);
            
            if (validUrls.length > 0) {
               if (type === 'main') {
                const mainImageList = validUrls.map(url => ({ url }));
                this.setData({
                  'form.mainImages': [...form.mainImages, ...validUrls],
                  mainImageList: [...this.data.mainImageList, ...mainImageList],
                  'errors.mainImages': ''
                });
                console.log('设置主图成功:', [...form.mainImages, ...validUrls]);
                wx.showToast({ 
                  title: `成功上传${validUrls.length}张图片`, 
                  icon: 'success'
                });
              } else if (type === 'cover') {
                this.setData({
                  'form.cover': validUrls[0],
                  coverImageList: [{ url: validUrls[0] }],
                  'errors.cover': ''
                });
                console.log('设置封面图成功:', validUrls[0]);
                wx.showToast({ title: '封面上传成功', icon: 'success' });
              }
            } else {
              // 只有当不是因为域名问题已经提示过的情况下才显示这个提示
              if (!tempPaths.some((_, i) => uploadResults[i] !== null)) {
                const errorMsg = type === 'main' ? '主图上传失败' : '封面上传失败';
                // 修复错误：正确设置错误信息
                if (type === 'main') {
                  this.setData({ 
                    'errors.mainImages': errorMsg 
                  });
                } else {
                  this.setData({ 
                    'errors.cover': errorMsg 
                  });
                }
                // 不再重复显示"上传失败"的提示，因为上面已经针对具体错误显示了提示
                if (!tempPaths.some(path => path.errMsg && path.errMsg.includes('url not in domain list'))) {
                  wx.showToast({ title: errorMsg, icon: 'none' });
                }
              }
            }
          }
        }
      });
    });
  },

  /**
   * 表单验证
   */
  validateForm() {
    const { form } = this.data;
    const errors = {
      title: "",
      content: "",
      type: "",
      scenicId: "",
      cover: "",
      mainImages: "",
    };
    let isValid = true;

    // 验证标题
    if (!form.title) {
      errors.title = "请输入标题";
      isValid = false;
    } else if (form.title.length > 50) {
      errors.title = "标题不能超过50个字符";
      isValid = false;
    }

    // 验证内容
    if (!form.content) {
      errors.content = "请输入内容";
      isValid = false;
    } else if (form.content.length > 2000) {
      errors.content = "内容不能超过2000个字符";
      isValid = false;
    }

    // 验证类型（确保单选已选择）
    if (form.type === null || form.type === undefined) {
      errors.type = "请选择内容类型";
      isValid = false;
    }

    // 验证景区（攻略和游记需要）
    if ((form.type === 1 || form.type === 2) && !form.scenicId) {
      errors.scenicId = "请选择景区";
      isValid = false;
    }

    // 验证图片
    if (form.type === 1 || form.type === 2) {
      // 攻略和游记需要封面和轮播图
      if (!form.cover) {
        errors.cover = "请上传封面图";
        isValid = false;
      }
      if (form.mainImages.length === 0) {
        errors.mainImages = "请上传轮播图";
        isValid = false;
      } else if (form.mainImages.length > 9) {
        errors.mainImages = "轮播图最多上传9张";
        isValid = false;
      }
    } else if (form.type === 3) {
      // 问答只需要封面
      if (!form.cover) {
        errors.cover = "请上传封面图";
        isValid = false;
      }
    }

    this.setData({ errors });
    return isValid;
  },

  /**
   * 提交表单
   */
  submitForm() {
    if (this.data.isSubmitting) return;
    if (!this.validateForm()) return;

    this.setData({ isSubmitting: true });
    wx.showLoading({ title: "发布中..." });

    const { form } = this.data;
    let url, data;

    // 根据类型设置不同的接口和参数
    switch (form.type) {
      case 1:
        // 攻略发布
        url = `${BASE_URL}/app/Intro/add`;
        data = {
          scenic_id: form.scenicId,
          bannar: form.mainImages.join(","), // 轮播图用逗号拼接
          introduce: form.content,
          title: form.title,
          user_id: userId,
          like_num: "11", // 按接口要求使用字符串类型
          collect_num: "11",
          img: form.cover,
        };
        break;

      case 2:
        // 游记发布
        url = `${BASE_URL}/app/Travels/add`;
        data = {
          banner: form.mainImages.join(","),
          user_id: userId,
          cover: form.cover,
          content: form.content,
          title: form.title,
        };
        break;

      case 3:
        // 问答发布
        url = `${BASE_URL}/app/Queans/add`;
        data = {
          user_id: userId,
          content: form.content,
          pid: "0", // 按接口要求使用字符串类型
        };
        break;

      default:
        wx.hideLoading();
        this.setData({ isSubmitting: false });
        wx.showToast({ title: "请选择内容类型", icon: "none" });
        return;
    }

    // 发送请求
    wx.request({
      url: url,
      method: "POST",
      header: {
        "content-type": "application/json",
        id: userId, // 头部传递用户 ID
      },
      data: data,
      success: (res) => {
        wx.hideLoading();
        try {
          // 检查响应是否为有效的JSON格式
          if (res.data && typeof res.data === "object") {
            if (res.data.code === 1) {
              wx.showToast({
                title: "发布成功",
                icon: "success",
                duration: 1500,
                success: () => {
                  setTimeout(() => {
                    wx.navigateBack(); // 发布成功返回上一页
                  }, 1500);
                },
              });
            } else {
              throw new Error(res.data.msg || "发布失败");
            }
          } else {
            throw new Error("服务器响应格式错误");
          }
        } catch (e) {
          console.error("发布请求解析失败：", e);
          wx.showToast({
            title: res.data?.msg || "发布失败",
            icon: "none",
          });
        }
      },
      fail: (error) => {
        wx.hideLoading();
        console.error("发布请求失败：", error);

        // 检查是否是域名不在合法域名列表中的错误
        if (error.errMsg && error.errMsg.includes("url not in domain list")) {
          wx.showToast({
            title: "请求域名未配置，请联系管理员",
            icon: "none",
            duration: 3000,
          });
        } else {
          wx.showToast({
            title: "网络错误，请重试",
            icon: "none",
          });
        }
      },
      complete: () => {
        this.setData({ isSubmitting: false });
      },
    });
  },

  /**
   * 返回上一页
   */
  handleBackBoxTap() {
    wx.navigateBack({ delta: 1 });
  },

  /**
   * 跳转到首页
   */
  jumpToHome() {
    wx.switchTab({ url: "/pages/index/index" });
  },
});